home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 November / PCWNOV08.iso / Software / Freeware / Adobe Media Player 1.1 / adobe_media_player.air / AMP.swf / scripts / mx / managers / PopUpManagerImpl.as < prev    next >
Encoding:
Text File  |  2008-07-17  |  22.5 KB  |  652 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.Graphics;
  6.    import flash.display.InteractiveObject;
  7.    import flash.display.Sprite;
  8.    import flash.display.Stage;
  9.    import flash.events.Event;
  10.    import flash.events.MouseEvent;
  11.    import flash.geom.Point;
  12.    import flash.geom.Rectangle;
  13.    import mx.automation.IAutomationObject;
  14.    import mx.core.ApplicationGlobals;
  15.    import mx.core.FlexSprite;
  16.    import mx.core.IChildList;
  17.    import mx.core.IFlexDisplayObject;
  18.    import mx.core.IInvalidating;
  19.    import mx.core.IUIComponent;
  20.    import mx.core.UIComponentGlobals;
  21.    import mx.core.mx_internal;
  22.    import mx.effects.Blur;
  23.    import mx.effects.Fade;
  24.    import mx.effects.IEffect;
  25.    import mx.events.EffectEvent;
  26.    import mx.events.FlexEvent;
  27.    import mx.events.FlexMouseEvent;
  28.    import mx.styles.IStyleClient;
  29.    
  30.    use namespace mx_internal;
  31.    
  32.    public class PopUpManagerImpl implements IPopUpManager
  33.    {
  34.       private static var instance:IPopUpManager;
  35.       
  36.       mx_internal static const VERSION:String = "3.0.0.0";
  37.       
  38.       private var popupInfo:Array;
  39.       
  40.       mx_internal var modalWindowClass:Class;
  41.       
  42.       public function PopUpManagerImpl()
  43.       {
  44.          super();
  45.       }
  46.       
  47.       private static function nonmodalMouseWheelOutsideHandler(param1:DisplayObject, param2:MouseEvent) : void
  48.       {
  49.          if(!param1.hitTestPoint(param2.stageX,param2.stageY,true))
  50.          {
  51.             if(param1 is IUIComponent)
  52.             {
  53.                if(IUIComponent(param1).owns(DisplayObject(param2.target)))
  54.                {
  55.                   return;
  56.                }
  57.             }
  58.             dispatchMouseWheelOutsideEvent(param1,param2);
  59.          }
  60.       }
  61.       
  62.       private static function dispatchMouseWheelOutsideEvent(param1:DisplayObject, param2:MouseEvent) : void
  63.       {
  64.          var _loc3_:MouseEvent = new FlexMouseEvent(FlexMouseEvent.MOUSE_WHEEL_OUTSIDE);
  65.          var _loc4_:Point = param1.globalToLocal(new Point(param2.stageX,param2.stageY));
  66.          _loc3_.localX = _loc4_.x;
  67.          _loc3_.localY = _loc4_.y;
  68.          _loc3_.buttonDown = param2.buttonDown;
  69.          _loc3_.shiftKey = param2.shiftKey;
  70.          _loc3_.altKey = param2.altKey;
  71.          _loc3_.ctrlKey = param2.ctrlKey;
  72.          _loc3_.delta = param2.delta;
  73.          _loc3_.relatedObject = InteractiveObject(param2.target);
  74.          param1.dispatchEvent(_loc3_);
  75.       }
  76.       
  77.       private static function dispatchMouseDownOutsideEvent(param1:DisplayObject, param2:MouseEvent) : void
  78.       {
  79.          var _loc3_:MouseEvent = new FlexMouseEvent(FlexMouseEvent.MOUSE_DOWN_OUTSIDE);
  80.          var _loc4_:Point = param1.globalToLocal(new Point(param2.stageX,param2.stageY));
  81.          _loc3_.localX = _loc4_.x;
  82.          _loc3_.localY = _loc4_.y;
  83.          _loc3_.buttonDown = param2.buttonDown;
  84.          _loc3_.shiftKey = param2.shiftKey;
  85.          _loc3_.altKey = param2.altKey;
  86.          _loc3_.ctrlKey = param2.ctrlKey;
  87.          _loc3_.delta = param2.delta;
  88.          _loc3_.relatedObject = InteractiveObject(param2.target);
  89.          param1.dispatchEvent(_loc3_);
  90.       }
  91.       
  92.       public static function getInstance() : IPopUpManager
  93.       {
  94.          if(!instance)
  95.          {
  96.             instance = new PopUpManagerImpl();
  97.          }
  98.          return instance;
  99.       }
  100.       
  101.       private static function nonmodalMouseDownOutsideHandler(param1:DisplayObject, param2:MouseEvent) : void
  102.       {
  103.          if(!param1.hitTestPoint(param2.stageX,param2.stageY,true))
  104.          {
  105.             if(param1 is IUIComponent)
  106.             {
  107.                if(IUIComponent(param1).owns(DisplayObject(param2.target)))
  108.                {
  109.                   return;
  110.                }
  111.             }
  112.             dispatchMouseDownOutsideEvent(param1,param2);
  113.          }
  114.       }
  115.       
  116.       private function showModalWindow(param1:PopUpData) : void
  117.       {
  118.          var _loc4_:Fade = null;
  119.          var _loc5_:Number = NaN;
  120.          var _loc6_:Object = null;
  121.          var _loc7_:Blur = null;
  122.          var _loc2_:IStyleClient = param1.owner as IStyleClient;
  123.          var _loc3_:Number = 0;
  124.          if(_loc2_)
  125.          {
  126.             _loc3_ = Number(_loc2_.getStyle("modalTransparencyDuration"));
  127.          }
  128.          endEffects(param1);
  129.          if(_loc3_)
  130.          {
  131.             _loc4_ = new Fade(param1.modalWindow);
  132.             _loc4_.alphaFrom = 0;
  133.             _loc4_.alphaTo = _loc2_.getStyle("modalTransparency");
  134.             _loc4_.duration = _loc3_;
  135.             _loc4_.addEventListener(EffectEvent.EFFECT_END,fadeInEffectEndHandler);
  136.             param1.modalWindow.alpha = 0;
  137.             param1.modalWindow.visible = true;
  138.             param1.fade = _loc4_;
  139.             IUIComponent(param1.owner).setVisible(false,true);
  140.             _loc4_.play();
  141.             _loc5_ = Number(_loc2_.getStyle("modalTransparencyBlur"));
  142.             if(_loc5_)
  143.             {
  144.                _loc6_ = "parentApplication" in param1.owner ? Object(param1.owner).parentApplication : null;
  145.                _loc7_ = new Blur(!!_loc6_ ? _loc6_ : ApplicationGlobals.application);
  146.                _loc7_.blurXFrom = _loc7_.blurYFrom = 0;
  147.                _loc7_.blurXTo = _loc7_.blurYTo = _loc5_;
  148.                _loc7_.duration = _loc3_;
  149.                _loc7_.addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  150.                param1.blur = _loc7_;
  151.                _loc7_.play();
  152.             }
  153.          }
  154.          else
  155.          {
  156.             IUIComponent(param1.owner).setVisible(true,true);
  157.             param1.modalWindow.visible = true;
  158.          }
  159.       }
  160.       
  161.       private function fadeInEffectEndHandler(param1:EffectEvent) : void
  162.       {
  163.          var _loc4_:PopUpData = null;
  164.          effectEndHandler(param1);
  165.          var _loc2_:int = int(popupInfo.length);
  166.          var _loc3_:int = 0;
  167.          while(_loc3_ < _loc2_)
  168.          {
  169.             _loc4_ = popupInfo[_loc3_];
  170.             if(_loc4_.modalWindow == param1.effectInstance.target)
  171.             {
  172.                IUIComponent(_loc4_.owner).setVisible(true,true);
  173.                break;
  174.             }
  175.             _loc3_++;
  176.          }
  177.       }
  178.       
  179.       public function bringToFront(param1:IFlexDisplayObject) : void
  180.       {
  181.          var _loc2_:PopUpData = null;
  182.          var _loc3_:ISystemManager = null;
  183.          if(Boolean(param1) && Boolean(param1.parent))
  184.          {
  185.             _loc2_ = findPopupInfoByOwner(param1);
  186.             if(_loc2_)
  187.             {
  188.                _loc3_ = ISystemManager(param1.parent);
  189.                if(_loc2_.topMost)
  190.                {
  191.                   _loc3_.popUpChildren.setChildIndex(DisplayObject(param1),_loc3_.popUpChildren.numChildren - 1);
  192.                }
  193.                else
  194.                {
  195.                   _loc3_.setChildIndex(DisplayObject(param1),_loc3_.numChildren - 1);
  196.                }
  197.             }
  198.          }
  199.       }
  200.       
  201.       private function popupShowHandler(param1:FlexEvent) : void
  202.       {
  203.          var _loc2_:PopUpData = findPopupInfoByOwner(param1.target);
  204.          if(_loc2_)
  205.          {
  206.             showModalWindow(_loc2_);
  207.          }
  208.       }
  209.       
  210.       private function fadeOutDestroyEffectEndHandler(param1:EffectEvent) : void
  211.       {
  212.          var _loc3_:ISystemManager = null;
  213.          effectEndHandler(param1);
  214.          var _loc2_:DisplayObject = DisplayObject(param1.effectInstance.target);
  215.          if(_loc2_.parent is ISystemManager)
  216.          {
  217.             _loc3_ = ISystemManager(_loc2_.parent);
  218.             if(_loc3_.popUpChildren.contains(_loc2_))
  219.             {
  220.                _loc3_.popUpChildren.removeChild(_loc2_);
  221.             }
  222.             else
  223.             {
  224.                _loc3_.removeChild(_loc2_);
  225.             }
  226.          }
  227.          else if(_loc2_.parent)
  228.          {
  229.             _loc2_.parent.removeChild(_loc2_);
  230.          }
  231.       }
  232.       
  233.       private function popupRemovedHandler(param1:Event) : void
  234.       {
  235.          var _loc4_:PopUpData = null;
  236.          var _loc5_:DisplayObject = null;
  237.          var _loc6_:DisplayObject = null;
  238.          var _loc7_:DisplayObject = null;
  239.          var _loc8_:ISystemManager = null;
  240.          var _loc2_:int = int(popupInfo.length);
  241.          var _loc3_:int = 0;
  242.          while(_loc3_ < _loc2_)
  243.          {
  244.             _loc4_ = popupInfo[_loc3_];
  245.             _loc5_ = _loc4_.owner;
  246.             if(_loc5_ == param1.target)
  247.             {
  248.                _loc6_ = _loc4_.parent;
  249.                _loc7_ = _loc4_.modalWindow;
  250.                _loc8_ = _loc6_ is ISystemManager ? ISystemManager(_loc6_) : IUIComponent(_loc6_).systemManager;
  251.                if(!_loc8_.isTopLevel())
  252.                {
  253.                   _loc8_ = _loc8_.topLevelSystemManager;
  254.                }
  255.                if(_loc5_ is IUIComponent)
  256.                {
  257.                   IUIComponent(_loc5_).isPopUp = false;
  258.                }
  259.                if(_loc5_ is IFocusManagerContainer)
  260.                {
  261.                   _loc8_.removeFocusManager(IFocusManagerContainer(_loc5_));
  262.                }
  263.                _loc5_.removeEventListener(Event.REMOVED,popupRemovedHandler);
  264.                if(_loc7_)
  265.                {
  266.                   _loc7_.removeEventListener(MouseEvent.MOUSE_DOWN,_loc4_.mouseDownOutsideHandler);
  267.                   _loc7_.removeEventListener(MouseEvent.MOUSE_WHEEL,_loc4_.mouseWheelOutsideHandler,true);
  268.                   _loc8_.removeEventListener(Event.RESIZE,_loc4_.resizeHandler);
  269.                   _loc5_.removeEventListener(FlexEvent.SHOW,popupShowHandler);
  270.                   _loc5_.removeEventListener(FlexEvent.HIDE,popupHideHandler);
  271.                   hideModalWindow(_loc4_,true);
  272.                   --_loc8_.numModalWindows;
  273.                }
  274.                else
  275.                {
  276.                   _loc8_.removeEventListener(MouseEvent.MOUSE_DOWN,_loc4_.mouseDownOutsideHandler);
  277.                   _loc8_.removeEventListener(MouseEvent.MOUSE_WHEEL,_loc4_.mouseWheelOutsideHandler,true);
  278.                }
  279.                popupInfo.splice(_loc3_,1);
  280.                break;
  281.             }
  282.             _loc3_++;
  283.          }
  284.       }
  285.       
  286.       private function hideModalWindow(param1:PopUpData, param2:Boolean = false) : void
  287.       {
  288.          var _loc5_:Fade = null;
  289.          var _loc6_:Number = NaN;
  290.          var _loc7_:Object = null;
  291.          var _loc8_:Blur = null;
  292.          var _loc3_:IStyleClient = param1.owner as IStyleClient;
  293.          var _loc4_:Number = 0;
  294.          if(_loc3_)
  295.          {
  296.             _loc4_ = Number(_loc3_.getStyle("modalTransparencyDuration"));
  297.          }
  298.          endEffects(param1);
  299.          if(_loc4_)
  300.          {
  301.             _loc5_ = new Fade(param1.modalWindow);
  302.             _loc5_.alphaFrom = param1.modalWindow.alpha;
  303.             _loc5_.alphaTo = 0;
  304.             _loc5_.duration = _loc4_;
  305.             _loc5_.addEventListener(EffectEvent.EFFECT_END,param2 ? fadeOutDestroyEffectEndHandler : fadeOutCloseEffectEndHandler);
  306.             param1.modalWindow.visible = true;
  307.             param1.fade = _loc5_;
  308.             _loc5_.play();
  309.             _loc6_ = Number(_loc3_.getStyle("modalTransparencyBlur"));
  310.             if(_loc6_)
  311.             {
  312.                _loc7_ = "parentApplication" in param1.owner ? Object(param1.owner).parentApplication : null;
  313.                _loc8_ = new Blur(!!_loc7_ ? _loc7_ : ApplicationGlobals.application);
  314.                _loc8_.blurXFrom = _loc8_.blurYFrom = _loc6_;
  315.                _loc8_.blurXTo = _loc8_.blurYTo = 0;
  316.                _loc8_.duration = _loc4_;
  317.                _loc8_.addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  318.                param1.blur = _loc8_;
  319.                _loc8_.play();
  320.             }
  321.          }
  322.          else
  323.          {
  324.             param1.modalWindow.visible = false;
  325.          }
  326.       }
  327.       
  328.       private function popupHideHandler(param1:FlexEvent) : void
  329.       {
  330.          var _loc2_:PopUpData = findPopupInfoByOwner(param1.target);
  331.          if(_loc2_)
  332.          {
  333.             hideModalWindow(_loc2_);
  334.          }
  335.       }
  336.       
  337.       private function effectEndHandler(param1:EffectEvent) : void
  338.       {
  339.          var _loc4_:PopUpData = null;
  340.          var _loc5_:IEffect = null;
  341.          var _loc2_:int = int(popupInfo.length);
  342.          var _loc3_:int = 0;
  343.          while(_loc3_ < _loc2_)
  344.          {
  345.             _loc4_ = popupInfo[_loc3_];
  346.             _loc5_ = param1.effectInstance.effect;
  347.             if(_loc5_ == _loc4_.fade)
  348.             {
  349.                _loc4_.fade = null;
  350.             }
  351.             else if(_loc5_ == _loc4_.blur)
  352.             {
  353.                _loc4_.blur = null;
  354.             }
  355.             _loc3_++;
  356.          }
  357.       }
  358.       
  359.       private function createModalWindow(param1:DisplayObject, param2:PopUpData, param3:IChildList, param4:Boolean) : void
  360.       {
  361.          var _loc5_:IFlexDisplayObject = null;
  362.          var _loc8_:Sprite = null;
  363.          _loc5_ = IFlexDisplayObject(param2.owner);
  364.          var _loc6_:IStyleClient = _loc5_ as IStyleClient;
  365.          var _loc7_:Number = 0;
  366.          if(mx_internal::modalWindowClass)
  367.          {
  368.             _loc8_ = new mx_internal::modalWindowClass();
  369.          }
  370.          else
  371.          {
  372.             _loc8_ = new FlexSprite();
  373.             _loc8_.name = "modalWindow";
  374.          }
  375.          var _loc9_:ISystemManager = IUIComponent(param1).systemManager;
  376.          ++_loc9_.numModalWindows;
  377.          param3.addChildAt(_loc8_,param3.getChildIndex(DisplayObject(_loc5_)));
  378.          if(_loc5_ is IAutomationObject)
  379.          {
  380.             IAutomationObject(_loc5_).showInAutomationHierarchy = true;
  381.          }
  382.          if(_loc6_)
  383.          {
  384.             _loc8_.alpha = _loc6_.getStyle("modalTransparency");
  385.          }
  386.          else
  387.          {
  388.             _loc8_.alpha = 0;
  389.          }
  390.          _loc8_.tabEnabled = false;
  391.          var _loc10_:Rectangle = _loc9_.screen;
  392.          var _loc11_:Graphics = _loc8_.graphics;
  393.          var _loc12_:Number = 16777215;
  394.          if(_loc6_)
  395.          {
  396.             _loc12_ = Number(_loc6_.getStyle("modalTransparencyColor"));
  397.          }
  398.          _loc11_.clear();
  399.          _loc11_.beginFill(_loc12_,100);
  400.          _loc11_.drawRect(_loc10_.x,_loc10_.y,_loc10_.width,_loc10_.height);
  401.          _loc11_.endFill();
  402.          param2.modalWindow = _loc8_;
  403.          param2._mouseDownOutsideHandler = dispatchMouseDownOutsideEvent;
  404.          param2._mouseWheelOutsideHandler = dispatchMouseWheelOutsideEvent;
  405.          _loc8_.addEventListener(MouseEvent.MOUSE_DOWN,param2.mouseDownOutsideHandler);
  406.          _loc8_.addEventListener(MouseEvent.MOUSE_WHEEL,param2.mouseWheelOutsideHandler,true);
  407.          _loc9_.addEventListener(Event.RESIZE,param2.resizeHandler);
  408.          _loc5_.addEventListener(FlexEvent.SHOW,popupShowHandler);
  409.          _loc5_.addEventListener(FlexEvent.HIDE,popupHideHandler);
  410.          if(param4)
  411.          {
  412.             showModalWindow(param2);
  413.          }
  414.          else
  415.          {
  416.             _loc5_.visible = param4;
  417.          }
  418.       }
  419.       
  420.       private function findPopupInfoByOwner(param1:Object) : PopUpData
  421.       {
  422.          var _loc4_:PopUpData = null;
  423.          var _loc2_:int = int(popupInfo.length);
  424.          var _loc3_:int = 0;
  425.          while(_loc3_ < _loc2_)
  426.          {
  427.             _loc4_ = popupInfo[_loc3_];
  428.             if(_loc4_.owner == param1)
  429.             {
  430.                return _loc4_;
  431.             }
  432.             _loc3_++;
  433.          }
  434.          return null;
  435.       }
  436.       
  437.       private function fadeOutCloseEffectEndHandler(param1:EffectEvent) : void
  438.       {
  439.          effectEndHandler(param1);
  440.          DisplayObject(param1.effectInstance.target).visible = false;
  441.       }
  442.       
  443.       private function endEffects(param1:PopUpData) : void
  444.       {
  445.          if(param1.fade)
  446.          {
  447.             param1.fade.end();
  448.             param1.fade = null;
  449.          }
  450.          if(param1.blur)
  451.          {
  452.             param1.blur.end();
  453.             param1.blur = null;
  454.          }
  455.       }
  456.       
  457.       public function removePopUp(param1:IFlexDisplayObject) : void
  458.       {
  459.          var _loc2_:PopUpData = null;
  460.          var _loc3_:ISystemManager = null;
  461.          var _loc4_:IUIComponent = null;
  462.          if(Boolean(param1) && Boolean(param1.parent))
  463.          {
  464.             _loc2_ = findPopupInfoByOwner(param1);
  465.             if(_loc2_)
  466.             {
  467.                _loc3_ = param1.parent as ISystemManager;
  468.                if(!_loc3_)
  469.                {
  470.                   _loc4_ = param1 as IUIComponent;
  471.                   if(!_loc4_)
  472.                   {
  473.                      return;
  474.                   }
  475.                   _loc3_ = _loc4_.systemManager;
  476.                }
  477.                if(_loc2_.topMost)
  478.                {
  479.                   _loc3_.popUpChildren.removeChild(DisplayObject(param1));
  480.                }
  481.                else
  482.                {
  483.                   _loc3_.removeChild(DisplayObject(param1));
  484.                }
  485.             }
  486.          }
  487.       }
  488.       
  489.       public function addPopUp(param1:IFlexDisplayObject, param2:DisplayObject, param3:Boolean = false, param4:String = null) : void
  490.       {
  491.          var _loc7_:ISystemManager = null;
  492.          var _loc8_:IChildList = null;
  493.          var _loc9_:* = false;
  494.          var _loc5_:Boolean = Boolean(param1.visible);
  495.          var _loc6_:DisplayObjectContainer = DisplayObjectContainer(param2.root);
  496.          if((!_loc6_ || _loc6_ is Stage) && param2 is IUIComponent)
  497.          {
  498.             _loc6_ = DisplayObjectContainer(IUIComponent(param2).systemManager);
  499.          }
  500.          if(_loc6_ is ISystemManager)
  501.          {
  502.             _loc7_ = ISystemManager(_loc6_);
  503.             if(!_loc7_.isTopLevel())
  504.             {
  505.                _loc7_ = _loc7_.topLevelSystemManager;
  506.             }
  507.             if(param1 is IUIComponent)
  508.             {
  509.                IUIComponent(param1).isPopUp = true;
  510.             }
  511.             if(!param4 || param4 == PopUpManagerChildList.PARENT)
  512.             {
  513.                _loc9_ = Boolean(_loc7_.popUpChildren.contains(param2));
  514.             }
  515.             else
  516.             {
  517.                _loc9_ = param4 == PopUpManagerChildList.POPUP;
  518.             }
  519.             _loc8_ = _loc9_ ? _loc7_.popUpChildren : _loc7_;
  520.             _loc8_.addChild(DisplayObject(param1));
  521.             param1.visible = false;
  522.             if(!popupInfo)
  523.             {
  524.                popupInfo = [];
  525.             }
  526.             var _loc10_:PopUpData = new PopUpData();
  527.             _loc10_.owner = DisplayObject(param1);
  528.             _loc10_.topMost = _loc9_;
  529.             popupInfo.push(_loc10_);
  530.             if(param1 is IFocusManagerContainer)
  531.             {
  532.                if(IFocusManagerContainer(param1).focusManager)
  533.                {
  534.                   _loc7_.addFocusManager(IFocusManagerContainer(param1));
  535.                }
  536.                else
  537.                {
  538.                   IFocusManagerContainer(param1).focusManager = new FocusManager(IFocusManagerContainer(param1),true);
  539.                }
  540.             }
  541.             if(param1 is IAutomationObject)
  542.             {
  543.                IAutomationObject(param1).showInAutomationHierarchy = true;
  544.             }
  545.             if(param1 is ILayoutManagerClient)
  546.             {
  547.                UIComponentGlobals.mx_internal::layoutManager.validateClient(ILayoutManagerClient(param1),true);
  548.             }
  549.             _loc10_.parent = param2;
  550.             if(param1 is IUIComponent)
  551.             {
  552.                IUIComponent(param1).setActualSize(IUIComponent(param1).getExplicitOrMeasuredWidth(),IUIComponent(param1).getExplicitOrMeasuredHeight());
  553.             }
  554.             if(param3)
  555.             {
  556.                this.createModalWindow(param2,_loc10_,_loc8_,_loc5_);
  557.             }
  558.             else
  559.             {
  560.                _loc10_._mouseDownOutsideHandler = nonmodalMouseDownOutsideHandler;
  561.                _loc10_._mouseWheelOutsideHandler = nonmodalMouseWheelOutsideHandler;
  562.                _loc7_.addEventListener(MouseEvent.MOUSE_DOWN,_loc10_.mouseDownOutsideHandler);
  563.                _loc7_.addEventListener(MouseEvent.MOUSE_WHEEL,_loc10_.mouseWheelOutsideHandler,true);
  564.                param1.visible = _loc5_;
  565.             }
  566.             param1.addEventListener(Event.REMOVED,popupRemovedHandler);
  567.             if(param1 is IFocusManagerContainer && _loc5_)
  568.             {
  569.                _loc7_.activate(IFocusManagerContainer(param1));
  570.             }
  571.             return;
  572.          }
  573.       }
  574.       
  575.       public function createPopUp(param1:DisplayObject, param2:Class, param3:Boolean = false, param4:String = null) : IFlexDisplayObject
  576.       {
  577.          var _loc5_:IUIComponent = new param2();
  578.          addPopUp(_loc5_,param1,param3,param4);
  579.          return _loc5_;
  580.       }
  581.       
  582.       public function centerPopUp(param1:IFlexDisplayObject) : void
  583.       {
  584.          var _loc3_:Point = null;
  585.          if(param1 is IInvalidating)
  586.          {
  587.             IInvalidating(param1).validateNow();
  588.          }
  589.          var _loc2_:PopUpData = findPopupInfoByOwner(param1);
  590.          if(Boolean(_loc2_) && Boolean(_loc2_.parent))
  591.          {
  592.             _loc3_ = new Point(0,0);
  593.             _loc3_ = _loc2_.parent.localToGlobal(_loc3_);
  594.             _loc3_ = param1.parent.globalToLocal(_loc3_);
  595.             param1.move(Math.round((_loc2_.parent.width - param1.width) / 2) + _loc3_.x,Math.round((_loc2_.parent.height - param1.height) / 2) + _loc3_.y);
  596.          }
  597.       }
  598.    }
  599. }
  600.  
  601. import flash.display.DisplayObject;
  602. import flash.events.Event;
  603. import flash.events.MouseEvent;
  604. import flash.geom.Rectangle;
  605. import mx.effects.Effect;
  606.  
  607. class PopUpData
  608. {
  609.    public var _mouseWheelOutsideHandler:Function;
  610.    
  611.    public var owner:DisplayObject;
  612.    
  613.    public var blur:Effect;
  614.    
  615.    public var parent:DisplayObject;
  616.    
  617.    public var _mouseDownOutsideHandler:Function;
  618.    
  619.    public var topMost:Boolean;
  620.    
  621.    public var fade:Effect;
  622.    
  623.    public var modalWindow:DisplayObject;
  624.    
  625.    public function PopUpData()
  626.    {
  627.       super();
  628.    }
  629.    
  630.    public function mouseWheelOutsideHandler(param1:MouseEvent) : void
  631.    {
  632.       _mouseWheelOutsideHandler(owner,param1);
  633.    }
  634.    
  635.    public function mouseDownOutsideHandler(param1:MouseEvent) : void
  636.    {
  637.       _mouseDownOutsideHandler(owner,param1);
  638.    }
  639.    
  640.    public function resizeHandler(param1:Event) : void
  641.    {
  642.       var _loc2_:Rectangle = ISystemManager(param1.target).screen;
  643.       if(Boolean(modalWindow) && owner.stage == DisplayObject(param1.target).stage)
  644.       {
  645.          modalWindow.width = _loc2_.width;
  646.          modalWindow.height = _loc2_.height;
  647.          modalWindow.x = _loc2_.x;
  648.          modalWindow.y = _loc2_.y;
  649.       }
  650.    }
  651. }
  652.